dpraimeyuu

module Data.FileOperations where

  import Prelude
  import Data.Maybe (Maybe(Nothing), Maybe(Just))
  import Data.String (contains, Pattern(Pattern))
  import Data.Array (foldl)
  import Data.Path

  whereIs :: Path -> String -> Maybe Path
  whereIs path filePattern =

dpraimeyuu

//invaluable for all those Choice<'a, exn> flows
let exnf f = Printf.ksprintf (fun s -> exn s) f

//combine paths
let (</>) x y = System.IO.Path.Combine(x, y)

//allows you to pattern match on values in the current scope rather than just literals
let (|Eq|_|) expected value =
    if expected = value then Some ()
    else None

dpraimeyuu

// This is am example of an immediate write / random access cursor for Excel with basic formatting options.
// Implementation is based on a concrete, non generic writer monad with no payload ("do!"" only) (only state).
// Instead of directl writing to excel, an alternatives would be a random acces to a 
// copy-on-write list (or even a mutable array) and then bulk-write the result to excel in one shot.
// When only forward access would have been required, a simple seq expression with yields would have been enough.
// Anyway, it is a demonstration on how to "hide" pseudo-mutable state that is passed through a computation.
// 
// I personally use it for generating reports based on various data sources.

dpraimeyuu

:: Sleep for N seconds:

ping localhost -n N -w 1



:: Get the date and time (US LOCALE ONLY)

set YEAR=%DATE:~-4,4%
set TWOYEAR=%DATE:~-2,2%

dpraimeyuu

namespace MyNamespace

type IMyInterface =
    abstract GetValue: unit -> string

type MyRecord = 
    { MyField1: int
      MyField2: string }
    interface IMyInterface with
        member x.GetValue() = x.MyField2

dpraimeyuu

  // Available variables:
  // - Machine
  // - interpret
  // - assign
  // - send
  // - sendParent
  // - spawn
  // - raise
  // - actions

dpraimeyuu

  // Available variables:
  // - Machine
  // - interpret
  // - assign
  // - send
  // - sendParent
  // - spawn
  // - raise
  // - actions

dpraimeyuu

  // Available variables:
  // - Machine
  // - interpret
  // - assign
  // - send
  // - sendParent
  // - spawn
  // - raise
  // - actions

dpraimeyuu

{
    "version": "0.1.0",
    "command": "cmd",
    "args": [
        "/c"
    ],
    "showOutput": "always",
    "echoCommand": true,
    "tasks": [
        {

dpraimeyuu

Architecture

• Use Onion architecture

  • Dependencies go inwards. That is, the Core domain doesn't know about outside layers

• Use pipeline model to implement workflows/use-cases/stories

  • Business logic makes decisions
  • IO does storage with minimal logic
  • Keep Business logic and IO separate

• Keep IO at edges