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

DISCLAIMER!

This page is unofficial and incomplete. Contributions are appreciated.

official doc

Language Features

Feature Haskell Nim
Comments -- single line, {- multiline -}(nestable) # single line, #[multiline]# (nestable)
Blocks Uses space and tab or C-like Uses indents like Python, another option is statement list expression
Operators operator is function (use (+) a b , or a + b), Operator has precedence, infix by default, Unicode syntax command call syntax unicode operators
Operator overloading None Operators are user defined except = and ., can overload: subscripts, curly subscripts a{b}, experimental call and dot operators
If/else statement None if a: foo() else: bar()
If/else expression if test then a else b if test: a else: b
case expression case t of m1 -> a
otherwise -> b
case t
of m1: a
else: b
Exception many ways, use Control.Monad, try: foo() except Exception as ex: bar() finally: bar() - can omit as ex or Exception as ex
Procedure definition id a = a, id::a->a for declare proc foo(a: U, b: S): T = discard in module
Method definition None method foo(obj: Obj, a: U, b: S): T = discard in module
Calling procedure func a b, or a `func` b foo(a, b), foo a, b, a.foo(b), a.foo b
Calling method None foo(obj, a, b), foo obj, a, b, obj.foo(a, b), obj.foo a, b
Method/procedure declarations are order-agnostic Yes No, can use forward declarations, experimental code reordering
String literals "str" "str", """str""", foo"str" (raw string literals)
Collection literals list comprehension [(a, b) | b <- ['a'..'z'], a <- [1..50], even a], Overloaded string and list array [1, 2, 3], seq @[1, 2, 3], set {1, 2, 3}, tuple (1, 2, 3), table constructor
compiler output hi interface file, native assembly or llvm translate to C, C++, Objective C , JavaScript
major compiler ghc nim
major REPL ghci inim
stability old young
meta-programming template-haskell macro keyword
template use {-# LANGUAGE CPP #-} template keyword
pure function IO Monad func keyword or noSideEffect pragma

Data Types

Haskell

Haskell is a pure functional language, variables are immutable.

However, you can use State Monad or IORef to get a mutable-like behaviour.

let behaves like create new immutable variable

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

In addition, where is the same

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]

Nim

var for mutable

let for immutable

const for compile-time symbol

var mutable = "some"
mutable &= " string"
let shadow_copy = mutable
const flags = ["--run", "--hints:off"]

Basic types present in Haskell and Nim:

Haskell Nim
Int8 int8
Int16 int16
Int32 int32
Int64 int64
Word8 uint8
Word16 uint16
Word32 uint32
Word64 uint64
Double float or float64 (same meaning)
Float float32
Ptr pointer
Bool bool

Available only in Haskell:

Haskell meaning
Integer Arbitrary precision integers
Ratio a numerator and denominator in type a
Rational aka Ratio Integer
Char represent Unicode code points
Complex a real and image number in type a
[a] List with element in type a
String aka [Char]

Only in Nim:

Nim meaning
char 1 byte character
string mutable chars
cstring pointer to memory, const char*
ptr[T] untraced pointer
ref[T] traced pointer
byte aka uint8

Nim has many additional types that enable the programmer to interface with C.

for Example: csize_t, cint, cshort

type inference

Both Haskell and Nim is static typed

Haskell's most widely used compiler (GHC) has strong type inference to determine what expression's type is

For example

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

The + function' signature is Num a => a -> a -> a, so add's parameter a and b must instance of Num. Int, Integer, Float, Double are instances of Num type classes. Use ::Type to tell explicitly the compiler the type of an expression.

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 ())

show's signature is Show a->String, we can say repr's parameter a must be an instance of the Show typeclass.

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

a :: [a] means a can be any type

Nim doesn't accept any type,

var arr: seq[int]
for i in 0..5:
  arr.add i
echo $arr

Lazyness

In Haskell, you can pass an expression to a function, and it's un-evaluated.

If you have an infinite list, you can take the first five elements, and calculate the result.

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

In Nim, an expression will be evaluated and passed to a function, so to pass large data to a function, you can pass by a pointer.

List example

type List[T] = object
   data: T
   next: ref List[T]

func fromArray[T](a: openarray[T]): ref List[T] = 
   new(result)
   var tmp = result
   tmp[].data = a[0]
   for i in 1..<len(a):
      new(tmp[].next)
      tmp = tmp.next
      tmp[].data = a[i]
   tmp.next = nil
   return result

proc `$`[T](a: ref List[T]): string = 
   result = "["
   var tmp = a
   while true:
     result.add($ tmp.data)
     if tmp.next==nil:
        break
     result.add ", "
     tmp = tmp.next
   result.add "]"

let a = fromArray [12, 45, 27, 64, 1024, 4096]

echo a

Documentation, libraries & popular tooling

Feature Haskell Nim
IDE support use Haskell Language Server, see VS Code, see editor support
Package manager cabal, stack, ghc-pkg Nimble
Library format hs source, hi interface, o object, see Source code, unused code is not included in binary (dead code elimination), can also compile to a shared library or static library
Style guide see NEP-1
Doc generator haddock nim doc, nim rst2html, nim tex, nim jsondoc, nim doc2tex
Unit testing HTF QuickCheck HUnit Standard library unittest module

Examples

Hello world

Haskell

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

compile

ghc Main.hs
./Main 
# or runghc Main.hs

Nim

echo "enter your name"
let a = stdin.readLine()
echo "hello " & a

compile

nim c Main.nim
./Main
# or nim c --run Main.nim

case

Haskell

case expression

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

pattern matching

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

Nim

var 
  a = 0
  b = 0
  res: int
let s = "+"

case s:
of "+": res = a + b 
of "-": res = a - b
else: res = -1

Algebraic Data Type

Haskell

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

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

Nim

type 
  ExprKind = enum
    Var, Lit, Lam, App
  Expr = ref object
    case kind: ExprKind
    of Var:
      name: string
    of Lit:
      val: float
    of App:
      a, b: Expr
    of Lam:
      n: string
      e: Expr

func eval(e: Expr): Expr = 
   case e.kind:
   of Var: ...

importing modules

{-# 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
  -}
-}

Nim

import System # exposes all symbols
import System as S # S W is the new name
from System import create # import create
import System except int # import all symbols except int
import system as S except int # S is the new name, int is not imported

# hello is a procedure, return some string
proc hello(): string {.inline.} = "hello " & "world"

# three ways to call
# they are the same
echo hello()
hello().echo
echo(hello())

#[
  #[
       multi-line comment
  ]#
]#
var mutable = "Win32"
mutable &= "API"

let immutable = ["Nim", "PlayGround", "C"]

const compileTime = 2 shl 1024

echo $mutable, $immutable, $compileTime

templates

Haskell

{-# 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)

nim

template curry(a, b, c) = 
  a (b, c)

curry(echo, 1, 2)

macros

Haskell

Macro.hs

{-# 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 |]

Main.hs

{-# LANGUAGE TemplateHaskell #-}

module Main where

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

Nim

import macros

macro readContent(path: static[string]): untyped = 
  let c = staticRead path
  result = newLit c

stdout.write readContent("Main.nim")

FFI

Haskell

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)))

Nim

proc sin(a: cdouble): cdouble {.importc, header: "math.h", nodecl.}

var i = 0.cdouble
while i < 0.05:
  echo sin(i)
  i += 0.001
⚠️ **GitHub.com Fallback** ⚠️