haskell 101 - hello world with cabal

I am in love with fp these days. In my opinion the cool thing about fp is about being deterministic. Just like in mathematics where a function f(x) = x * x always returns a same output for a given input.

I have been in situtations where I had to debug in exising applications where reference is passed around all over the place and mutated in multiple places. It is very dificult to trace mutations. I'm still learning fp but this week decided to do some haskell as if I'm building a professional application so that I can also learn the tooling in haskell.

So, the first step is to install cabal package manager which is equivalent to sbt, gradle or maven in JVM world.

$ cabal --version
cabal-install version 2.0.0.0
compiled using version 2.0.0.2 of the Cabal library 

With cabal installed in a machine next step is to create a create a haskell project with base structures which is what cabal init does.

mkdir infp
cd infp
cabal init

Otherwise there is always an option to create those file by yourself.

The structure of a project looks like

$ tree .
.
├── ChangeLog.md
├── LICENSE
├── Setup.hs
├── infp-world.cabal
└── src
    └── Main.hs

1 directory, 5 files

*.cabal equivalent to pom.xml of JVM world for dependency management and application artifact creation etc which will look like

name:                infp-world
version:             0.1.0.0
license:             BSD3
license-file:        LICENSE
author:              prayagupd
maintainer:          upd@upd.com
build-type:          Simple
extra-source-files:  ChangeLog.md
cabal-version:       >=1.10

executable infp-world
  main-is:             Main.hs
  hs-source-dirs:      src
  build-depends:       base >=4.10 && <4.11
  default-language:    Haskell98

build-depends section is where I have to add external dependencies which are available in http://hackage.haskell.org/packages/

For example if I need mongodb driver http://hackage.haskell.org/package/mongoDB could be the one which I would add as

build-depends:       base >=4.10 && <4.11,
                     mongodb == 2.4.0.0

For this application we simply want to print the system time so lets use the time package,

build-depends:       base >=4.10 && <4.11,
                     time == 1.9.2

Followed by cabal install to download the dependencies which will be installed to ~/.cabal/packages/ pretty much same as ~/.m2/repository in JVM world.

Now, now the next step is to add some functionality to get system time in main function.

To do that let's create following src/Main.hs. Note to edit the file, you can use vim or emacs with autocomplete (I use spacemacs - https://github.com/syl20bnr/spacemacs/tree/master/layers/%2Blang/haskell).

module Main where

import Data.Time
import Control.Applicative

main :: IO ()
main = do
  time <- getZonedTime
  putStrLn ("current time: " ++ show time)

lets build the project now which will create an executable in dist.

$ cabal build
Preprocessing executable 'infp-world' for infp-world-0.1.0.0..
Building executable 'infp-world' for infp-world-0.1.0.0..

It's good to see no compilation error, so it is good to run now with cabal run,

$ cabal run
Preprocessing executable 'infp-world' for infp-world-0.1.0.0..
Building executable 'infp-world' for infp-world-0.1.0.0..
Running infp-world...
current time: 2018-11-22 22:54:06.355117 PST

There we go, it prints current time: 2018-11-22 22:54:06.355117 PST which is the what we wanted.

So, there I end the hello world in haskell using cabal package manager. I am doing REST API on haskell as well so at some point plan to write a post on that.

clojure epoch time to LocalDateTime to UTC

Part 1 - epoch millis to LocalDateTime in machine with PST Zone 

user=> (import java.util.TimeZone)
java.util.TimeZone
user=> (TimeZone/getDefault)
#object[sun.util.calendar.ZoneInfo 0x36a7961e "sun.util.calendar.ZoneInfo[id=\"America/Los_Angeles\",offset=-28800000,dstSavings=3600000,useDaylight=true,transitions=185,lastRule=java.util.SimpleTimeZone[id=America/Los_Angeles,offset=-28800000,dstSavings=3600000,useDaylight=true,startYear=0,startMode=3,startMonth=2,startDay=8,startDayOfWeek=1,startTime=7200000,startTimeMode=0,endMode=3,endMonth=10,endDay=1,endDayOfWeek=1,endTime=7200000,endTimeMode=0]]"]

user=> (import java.time.ZoneId)
user=> (import java.time.Instant)

user=> (.atZone (Instant/ofEpochMilli (long 1500318045000)) (ZoneId/systemDefault))
#object[java.time.ZonedDateTime 0x386969fa "2017-07-17T12:00:45-07:00[America/Los_Angeles]"]

user=> (.toLocalDateTime (.atZone (Instant/ofEpochMilli (long 1500318045000)) (ZoneId/systemDefault)))
#object[java.time.LocalDateTime 0x778e9284 "2017-07-17T12:00:45"]

Same epoch millis on a machine with UTC Zone, 

scala> import java.time.Instant
scala> import java.util.TimeZone

scala> TimeZone.getDefault
res9: java.util.TimeZone = sun.util.calendar.ZoneInfo[id="UTC",offset=0,dstSavings=0,useDaylight=false,transitions=0,lastRule=null]

scala> Instant.ofEpochMilli(1500318045000l).atZone(ZoneId.systemDefault()).toLocalDateTime
res10: java.time.LocalDateTime = 2017-07-17T19:00:45

// to milis to UTC
scala> Instant.ofEpochMilli(1500318045000l).atZone(ZoneId.of("UTC")).toInstant.toString
res36: String = 2017-07-17T19:00:45Z

Part 2 - Converting date-string to LocalDateTime and ZonedDateTime

user=> (import java.time.format.DateTimeFormatter)
user=> (import java.time.ZoneId)
user=> (import java.util.TimeZone)
user=> (import java.time.LocalDateTime)

(let [formatter  (DateTimeFormatter/ofPattern "yyyy-MM-dd'T'HH:mm")
       localDate   (LocalDateTime/parse "2017-01-28T04:00" formatter)
       myZone     (ZoneId/of "America/Chicago")
       zonedDate (.atZone localDate myZone)
       instant     (.toInstant zonedDate)]
       (print (.toString instant)))

2017-01-28T10:00:00Z