Soares Chen soareschen

I hereby claim:

To claim this, I am signing this object:

	// This is an example use of the extensible builder pattern in Context-Generic Programming (CGP)
	// to progressively build a struct with missing fields filled with default values.
	//
	// This is in response to the question at https://www.reddit.com/r/rust/comments/1m4d8a8/how_to_handle_default_values_for_parameters/.
	// More info at https://contextgeneric.dev/blog/extensible-datatypes-part-1/

	use cgp::core::field::CanFinalizeWithDefault;
	use cgp::prelude::*;

	#[derive(Default)]

	// This is a response on how to use Context-Generic Programming (CGP)
	// to solve the specialization problem in the following blog post:
	// https://oakchris1955.eu/posts/bypassing_specialization/
	//
	// More info available at https://contextgeneric.dev/.

	use cgp::core::error::ErrorTypeProviderComponent;
	use cgp::prelude::*;

	// Redesign the FileSystem trait with CGP

	// This is an example of how the Scala cake pattern can be used in CGP,
	// following the example at https://www.baeldung.com/scala/cake-pattern

	pub mod traits {
	use std::collections::BTreeMap;

	use anyhow::Error;
	use cgp::prelude::*;

	// For simplicity of the example, we use `dyn` trait to represent test cases

	{-# LANGUAGE GADTs #-}
	{-# LANGUAGE RankNTypes #-}
	{-# LANGUAGE KindSignatures #-}
	{-# LANGUAGE ImplicitParams #-}
	{-# LANGUAGE ConstraintKinds #-}
	{-# LANGUAGE ExistentialQuantification #-}

	import GHC.Exts

	-- Dict Typing - Duck Typing in Haskell using dictionaries and implicits

	{-# LANGUAGE GADTs #-}
	{-# LANGUAGE RankNTypes #-}
	{-# LANGUAGE ImplicitParams #-}
	{-# LANGUAGE ConstraintKinds #-}

	import GHC.Exts

	-- A handler holds a function that takes in any a that
	-- satisfies constraint p. Note that we are simply returning
	-- string in here for the sake of simplifying the demo.

	{-# LANGUAGE GADTs #-}
	{-# LANGUAGE DataKinds #-}
	{-# LANGUAGE KindSignatures #-}
	{-# LANGUAGE ExplicitForAll #-}
	{-# LANGUAGE ConstraintKinds #-}
	{-# LANGUAGE FlexibleContexts #-}
	{-# LANGUAGE FlexibleInstances #-}
	{-# LANGUAGE ScopedTypeVariables #-}
	{-# LANGUAGE MultiParamTypeClasses #-}

	module Main where

	import Prelude
	import Data.Record
	import Control.Monad.Eff (Eff)
	import Control.Monad.Eff.Console (CONSOLE, log)

	fooHandler :: forall r. { foo :: String \| r } -> String
	fooHandler args = "(foo-handler " <> args.foo <> ")"