ramda vs F#

F#

#r "node_modules/fable-core/Fable.Core.dll"


open Fable.Core

// Grid abstarct (Middle Layer)

type GridLineTypes =
    | None = 0
    | Solid = 1
    | Dashed = 2

type GridLines = {
    Left: GridLineTypes
    Top: GridLineTypes
    Right: GridLineTypes
    Bottom: GridLineTypes
}

type GridCell =
    | Space
    | Block
    | Interface
    | Lines of GridLines

type Grid = GridCell[][]


// Grid draw (Bottom Layer)

type DrawLine = {
    X1: int
    Y1: int
    X2: int
    Y2: int
    Type: GridLineTypes
}

type DrawLines = {
    Left: DrawLine
    Right: DrawLine
    Top: DrawLine
    Bottom: DrawLine
}

type DrawRect = {
    X: int
    Y: int
    W: int
    H: int
}

type DrawEnty =
    | DrawNothing
    | DrawRect of DrawRect
    | DrawLines of DrawLines

let LINE_WIDTH = 25
let CELL_HEIGHT = 25
let BLOCK_WIDTH = 50
let BLOCK_WH_RATE = 0.5
let BLOCK_HEIGHT = BLOCK_WIDTH * int BLOCK_WH_RATE
let BLOCK_HALF_HEIGHT = BLOCK_WIDTH * int BLOCK_WH_RATE

let drawLines x y (gridLines: GridLines) =
    let tmpl = { Type = GridLineTypes.None; X1 = x; Y1 = y ; X2 = x; Y2 = y }
    {
        Left = { tmpl with Type = gridLines.Left; X2 = x + LINE_WIDTH / 2 }
        Top = { tmpl with Type = gridLines.Top; X1 = x + LINE_WIDTH / 2; X2 = x + LINE_WIDTH / 2; Y2 = y + BLOCK_HALF_HEIGHT }
        Right = { tmpl with Type = gridLines.Right; X1 = x + LINE_WIDTH / 2; X2 = x + LINE_WIDTH }
        Bottom =  { tmpl with Type = gridLines.Bottom; X1 = x + LINE_WIDTH / 2; X2 = x + LINE_WIDTH / 2; Y2 = y - BLOCK_HALF_HEIGHT }
    }

let drawRect x y = { X = x; Y = y; W = BLOCK_WIDTH; H = BLOCK_HEIGHT }

let gridAbstract2Draw grid =

    grid
    |> Array.mapi(fun irow row ->
        let y = irow * BLOCK_HEIGHT
        row
        |> Array.mapFold(fun x cell ->
            match cell with
            | Space ->
                let rect = drawRect x y
                DrawNothing, x + rect.W
            | Block ->
                let rect = drawRect x y
                DrawRect(rect), x + rect.W
            | Lines lines ->
                let ls = drawLines x y lines
                DrawLines(ls), x + (ls.Right.X2 - ls.Left.X1)
            | Interface ->
                let rect = drawRect x y
                DrawRect(rect), x + rect.W
        ) 0
        |> fst
    )
    |> Array.concat
    |> Array.filter (function | DrawNothing -> false | _ -> true)

ramda

//Thats why even ramda is terrific in conjuction with type script, no type inference at all, assign all types manually if you want typesafety

import * as R from 'ramda';

type GridLineTypes = "none" | "solid" | "dashed"

type GridLines = {
    left: GridLineTypes
    top: GridLineTypes
    right: GridLineTypes
    bottom: GridLineTypes
}

type GridCell =
      {$type : "space"}
    | {$type: "block"}
    | {$type: "interface"}
    | {$type: "lines", lines: GridLines}

type Grid = GridCell[][]

// Grid draw (Bottom Layer)

type DrawLine = {
    x1: number
    y1: number
    x2: number
    y2: number
    type: GridLineTypes
}

type DrawLines = {
    left: DrawLine
    right: DrawLine
    top: DrawLine
    bottom: DrawLine
}

type DrawRect = {
    x: number
    y: number
    w: number
    h: number
}

type DrawEnty =
      { $type: "drawNothing" }
    | { $type: "drawRect", drawRect: DrawRect }
    | { $type: "drawLines", drawLines: DrawLines }

const LINE_WIDTH = 25
const CELL_HEIGHT = 25
const BLOCK_WIDTH = 50
const BLOCK_WH_RATE = 0.5
const BLOCK_HEIGHT = BLOCK_WIDTH * BLOCK_WH_RATE
const BLOCK_HALF_HEIGHT = BLOCK_WIDTH * BLOCK_WH_RATE

const _with = <T extends U, U>(obj: T, wth: U) : T =>
    (<any>Object).extends({}, obj, wth)

const drawLines = (x: number, y: number, gridLines: GridLines) => {
    let tmpl: DrawLine = { type: "none", x1: x, y1: y, x2: x, y2: y };
    return {
        left: _with(tmpl, { type: gridLines.left, x2: x + LINE_WIDTH / 2 }),
        top: _with(tmpl, { type: gridLines.top, x1: x + LINE_WIDTH / 2, x2: x + LINE_WIDTH / 2, y2: y + BLOCK_HALF_HEIGHT }),
        right: _with(tmpl, { type: gridLines.right, x1: x + LINE_WIDTH / 2, x2: x + LINE_WIDTH }),
        bottom: _with(tmpl, { type: gridLines.bottom, x1: x + LINE_WIDTH / 2, x2: x + LINE_WIDTH / 2, y2: y - BLOCK_HALF_HEIGHT })
    }
}

const drawRect = (x: number, y: number) => ({ x, y, w: BLOCK_WIDTH, h: BLOCK_HEIGHT })

let gridAbstract2Draw = (grid: Grid) : DrawEnty[] =>
    R.pipe(
        R.addIndex(R.chain)((row: GridCell[], irow: number) => {
        let y = irow * BLOCK_HEIGHT
        R.mapAccum((x, cell) => {
            switch(cell.$type) {
                case "space": {
                    let rect = drawRect(x, y);
                    return [x + rect.w, <DrawEnty>{$type : "drawNothing"}];
                }
                case "block": {
                    let rect = drawRect(x, y);
                    return [x + rect.w, <DrawEnty>{$type: "drawRect", drawRect: rect}];
                }
                case "lines": {
                    let ls = drawLines(x, y, cell.lines);
                    return [x + (ls.right.x2 - ls.left.x1), <DrawEnty>{$type: "drawLines", drawLines: ls}]
                }
                case "interface": {
                    let rect = drawRect(x,y);
                    return [ x + rect.w, <DrawEnty>{$type: "drawRect", drawRect: rect}];
                }
            }
        }, 0, row)[1]
        }),
        (x: DrawEnty[]) => R.filter(y => y.$type !== "drawNothing", x)
    )(grid);