Nim for Haskell Programmers - nim-lang/Nim GitHub Wiki

quicksort :: (Ord a) => [a] -> [a]
quicksort [] = []
quicksort (x:xs) =
  let smaller = quicksort [a | a<-xs, a<=x]
      bigger  = quicksort [a | a<-xs, a>x]
  in  smaller ++ [x] ++ bigger

quicksort :: (Ord a) => [a] -> [a]
quicksort [] = []
quicksort (x:xs) = smaller ++ [x] ++ bigger
    where
       smaller = quicksort [a | a<-xs, a<=x]
       bigger  = quicksort [a | a<-xs, a>x]

Prelude> :t 25
25:: Num a => a
Prelude> add a b = a+b
Prelude> :t add
add :: Num a => a -> a -> a
Prelude> add 1 2
3
Prelude> add 1.0 2.0
3.0
Prelude> (add 1 2)::Int
3
Prelude> (add 1 2)::Integer
3
Prelude> (add 1 2)::Float
3.0
Prelude> (add 1 2)::Double
3.0

Prelude> :{
Prelude| repr::(Show a)=>a->String
Prelude| repr a = "repr " ++ (show a)
Prelude| :}
Prelude> repr 23
"repr 23"
Prelude> repr [1..5]
"repr [1,2,3,4,5]"
Prelude> repr (return ()::IO ())

<interactive>:7:1: error:
    * No instance for (Show (IO ())) arising from a use of `repr'
    * In the expression: repr (return () :: IO ())
      In an equation for `it': it = repr (return () :: IO ())

Prelude> a = []
Prelude> :t a
a :: [a]
Prelude> a ++ ['a'..'d']
"abcd"
Prelude> a ++ [1..5]
[1,2,3,4,5]

main = do
    let a = [0..]::[Int]
    print $ take 5 a

main = do
  print "enter your name"
  a <- getLine
  print $ "hello " ++ a

case (parse "<string>" number "45") of (Right x) -> x
                                       (Left err) -> print err >> fail "parse error"

fib :: Integer -> Integer
fib 0 = 0
fib 1 = 1
fib n = fib (n-1) + fib (n-2)
fibs::[Integer]
fibs = 1 : 1 : zipWith (+) fibs (tail fibs)
main = print $ take 10 fibs

data Value = IVal Integer | FVal Double deriving (Show, Eq)

data Expr
  = Var String
  | Lit Value
  | App Expr Expr
  | Lam String Expr
  deriving (Eq, Show)

{-# LANGUAGE Unsafe #-} -- since Unsafe.Coerce is unsafe, use LANGUAGE pragma to mark this module unsafe
module Main (hello) where -- expose hello function

import Unsafe.Coerce -- expose all symbols
import qualified Control.Monad.Writer as W -- W is the new name
import Data.ByteString hiding (putStrLn) -- readFile is not visible
import Data.Semigroup ((<>), Semigroup) -- import (<>) function and Semigroup typeclass

hello::String -- hello is type String, aka [Char]
{-# INLINABLE hello #-} -- tell ghc hello is inlinable
hello = "Hello "<>"world" -- the function body

main::IO () -- main is the entry point of the program, main is an empty tuple inside the IO Monad
main = putStrLn hello -- call putStrLn
{-
  {-
    multi-line comment
  -}
-}

{-# LANGUAGE CPP #-}

#define bind(a, f) a <- f
#define COUNT 5

main::IO ()

main = do
  putStrLn "enter a number->"
  bind(s, getLine)
  bind(num, readIO s)::IO Integer
  print $ scanl (+) 0 (take COUNT $ repeat num)

{-# LANGUAGE TemplateHaskell #-}
module Macro
  ( duplicate )
where

import Language.Haskell.TH
import Language.Haskell.TH.Syntax

duplicate :: String -> Q Exp
duplicate s = do
  [| fromString s++s |]

{-# LANGUAGE TemplateHaskell #-}

module Main where

import Macro
main :: IO ()
main = putStrLn $(duplicate "<>")

module Main where
import Prelude hiding (sin)
import Foreign.C.Types

-- stdcall in windows
foreign import ccall "math.h sin"
    sin::CDouble->CDouble

main = print $ map sin (take 50 (scanl (+) 0 (repeat 0.001)))