Savelenko

(* An experiment with implementing early return in F#. Initial examples work, but I do not know whether it is really correct! *)

/// A computation which runs to completion and produces 'r or returns an 'a early, short-circuiting some steps.
type R<'a,'r> =
    private
    | Done of 'r
    | EarlyReturn of 'a
    | Zero
    | Effect of (unit -> R<'a,'r>)

tgrapperon

import SwiftUI

struct ContentView: View {
  @State var path: [String] = []

  func navigationButton(value: String) -> some View {
    NavigationButton {
      path.append(value)
    } label: {
      Text("NavigationButton")

mr-salty

#! /bin/bash -e
#
# clean up everything in CACHE_DIR last accessed more than DAYS days ago.
# also removes files with bogus timestamps in the future.
#
# -----------------------------------------------------------------------
# Copyright 2021 Todd Derr (todd.derr@gmail.com)
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.

Savelenko

// The engine interface and helpers

type IEngine<'a,'b> =
    abstract member Capacity : int // Does not depend on 'a or 'b; just an example
    // Some other stuff here possible depending on 'a and 'b

/// A function which works on any engine polymorphically and returns a result of type 'r'. Needed because
/// F# does not support higher-ranked types (not the same as HKT!) in regular functions. This does work in members.
type EngineFunction<'r> =
    abstract member Apply : IEngine<'a,'b> -> 'r

johnynek

import scala.util.Try

object PathSerializer {

  trait SerDe[A] {
    // By using a path dependent type, we can be sure can deserialize without wrapping in Try
    type Serialized
    def ser(a: A): Serialized
    def deser(s: Serialized): A
    // If we convert to a generic type, in this case String, we forget if we can really deserialize

steipete

//
//  PSPDFFastEnumeration.h
//  PSPDFFoundation
//
//  PSPDFKit is the leading cross-platform solution for integrating PDFs into your apps: https://pspdfkit.com.
//  Try it today using our free PDF Viewer app: https://pdfviewer.io/
//
//  This file is MIT licensed. 

@protocol PSPDFFastEnumeration <NSFastEnumeration>

bmc

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import java.util.Date
import java.text.SimpleDateFormat
import fs2._

// id and gender should really be more strongly-typed, but
// this is just a demo...
case class Person(id:         Int,
                  firstName:  String,

gallais

(*
   We don't really care about the data constructors here
   but they are needed, cf:
   https://sympa.inria.fr/sympa/arc/caml-list/2013-10/msg00190.html
 *)
type zero    = Zero
type 'a succ = Succ

(*
   []   has length 0

jdegoes

Applied Functional Programming with Scala - Notes

Copyright © 2016-2018 Fantasyland Institute of Learning. All rights reserved.

1. Mastering Functions

A function is a mapping from one set, called a domain, to another set, called the codomain. A function associates every element in the domain with exactly one element in the codomain. In Scala, both domain and codomain are types.

val square : Int => Int = x => x * x

mandubian

Here is a fast explanation on this study for Freek to improve compile-time:

https://github.com/ProjectSeptemberInc/freek/blob/optim/cop/src/main/scala/CoproductK.scala#L14-L34

In Freek, Higher-Kinded Coproduct was based on Shapeless HList/Coproduct representation like:

sealed trait CoproductK[A] extends Product with Serializable

sealed trait CNilK[A] extends CoproductK[A]