tomlokhorst

{-# LANGUAGE
    TypeOperators
  , TemplateHaskell
  #-}
module Tie where

import Prelude hiding ((.), id)
import Control.Category
import Data.Record.Label

tomlokhorst

func unwrap<T1, T2>(optional1: T1?, optional2: T2?) -> (T1, T2)? {
  switch (optional1, optional2) {
    case let (.Some(value1), .Some(value2)):
      return (value1, value2)
    default:
      return nil
  }
}

func unwrap<T1, T2, T3>(optional1: T1?, optional2: T2?, optional3: T3?) -> (T1, T2, T3)? {

tomlokhorst

// Monad type class ported to C#
// Only tested with: Mono C# compiler version 2.4.2.3
//
// The Monad type class has been split up into two .NET interface:
//  - IMonad<A> has functions that can be applied _to_ monads (i.e. bind)
//  - IMonadDictionary<A> has functions that _create_ monads (i.e. unit)
//
// Because .NET doesn't support higher kinded generics, we loose a bit of
// type safety. After calling `bind`, the return value has to be casted to
// the proper type.

tomlokhorst

import UIKit

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
  var window: UIWindow?

  func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    print(process(MyFoo()))
    return true
  }

tomlokhorst

/// - returns: `true` when dynamic type is `Equatable` and `==` returns `true`, otherwise `false`.
func areEquatablyEqual(_ lhs: Any, _ rhs: Any) -> Bool {
    func receiveLHS<LHS>(_ typedLHS: LHS) -> Bool {
        guard
            let rhsAsLHS = rhs as? LHS
            else { return false }
        return areEquatablyEqual(typedLHS, rhsAsLHS)
    }
    return _openExistential(lhs, do: receiveLHS)
}

tomlokhorst

//
//  DarwinNotificationCenter.swift
//
//  Created by Nonstrict on 2023-12-07.
//

import Foundation
import Combine

private let center = CFNotificationCenterGetDarwinNotifyCenter()