Skip to content
This repository was archived by the owner on Jul 11, 2025. It is now read-only.

Latest commit

 

History

History
1315 lines (1067 loc) · 40.4 KB

Boolean-Guide.md

File metadata and controls

1315 lines (1067 loc) · 40.4 KB

Boolean: A Real-World Guide

Table of Contents

  1. Introduction & Core Concepts
  2. Basic Usage Patterns
  3. Real-World Examples
  4. Advanced Features Deep Dive
  5. Practical Patterns & Best Practices
  6. Integration Examples

Introduction & Core Concepts

The Problem Boolean Solves

Traditional boolean logic in JavaScript often leads to repetitive validation code, nested conditionals, and difficulty composing complex logical expressions in a readable way.

// Traditional approach - scattered boolean logic
function validateUserPermissions(user: any, resource: any, action: any): boolean {
  // Nested conditionals become hard to read
  if (user.isActive) {
    if (user.role === 'admin') {
      return true
    } else if (user.role === 'user') {
      if (resource.isPublic || resource.ownerId === user.id) {
        if (action === 'read' || action === 'write') {
          return true
        }
      }
    }
  }
  return false
}

// Complex boolean combinations without clear composition
function isEligibleForDiscount(user: any, order: any): boolean {
  const isPremium = user.membershipLevel === 'premium'
  const hasLargeOrder = order.total > 100
  const isFirstTime = user.orderCount === 0
  const hasPromoCode = order.promoCode && order.promoCode.length > 0
  
  // Logic becomes hard to understand and maintain
  return (isPremium && hasLargeOrder) || 
         (isFirstTime && hasPromoCode) || 
         (!isPremium && hasLargeOrder && hasPromoCode)
}

// Boolean array operations with manual loops
function checkAllPermissions(permissions: boolean[]): boolean {
  for (const permission of permissions) {
    if (!permission) return false
  }
  return true
}

This approach leads to:

  • Poor Readability - Complex nested conditionals are hard to understand
  • Lack of Composition - Difficult to build reusable logical components
  • Error-Prone Logic - Easy to make mistakes in complex boolean expressions
  • Maintenance Burden - Changes to business logic require extensive refactoring

The Boolean Solution

Effect's Boolean module provides functional, composable tools for building clear, maintainable boolean logic with excellent readability and type safety.

import { Boolean, Array as Arr, pipe } from "effect"

// Composable permission checking with clear intent
const isActiveUser = (user: User): boolean => user.isActive
const isAdmin = (user: User): boolean => user.role === 'admin'
const canAccessResource = (user: User, resource: Resource): boolean =>
  resource.isPublic || resource.ownerId === user.id
const canPerformAction = (action: string): boolean =>
  action === 'read' || action === 'write'

const validateUserPermissions = (user: User, resource: Resource, action: string): boolean =>
  pipe(
    isActiveUser(user),
    Boolean.and(
      Boolean.or(
        isAdmin(user),
        Boolean.and(
          user.role === 'user',
          Boolean.and(
            canAccessResource(user, resource),
            canPerformAction(action)
          )
        )
      )
    )
  )

// Clear boolean algebra with functional composition
const isEligibleForDiscount = (user: User, order: Order): boolean => {
  const isPremium = user.membershipLevel === 'premium'
  const hasLargeOrder = order.total > 100
  const isFirstTime = user.orderCount === 0
  const hasPromoCode = order.promoCode && order.promoCode.length > 0
  
  const premiumLargeOrder = Boolean.and(isPremium, hasLargeOrder)
  const firstTimeWithPromo = Boolean.and(isFirstTime, hasPromoCode)
  const regularLargeOrderWithPromo = pipe(
    Boolean.not(isPremium),
    Boolean.and(hasLargeOrder),
    Boolean.and(hasPromoCode)
  )
  
  return Boolean.or(
    premiumLargeOrder,
    Boolean.or(firstTimeWithPromo, regularLargeOrderWithPromo)
  )
}

// Functional array operations
const checkAllPermissions = Boolean.every
const checkAnyPermission = Boolean.some

Key Concepts

Logical Operators: Boolean.and, Boolean.or, Boolean.not provide functional equivalents to &&, ||, ! with composability

Boolean Algebra: Advanced operations like Boolean.xor, Boolean.nand, Boolean.implies for complex logical expressions

Pattern Matching: Boolean.match enables clean conditional logic without nested if statements

Collection Operations: Boolean.every and Boolean.some for validating arrays of boolean values

Basic Usage Patterns

Pattern 1: Basic Logical Operations

import { Boolean } from "effect"

// Basic logical operations with clear semantics
const isValid = true
const isActive = false

// AND operation - both must be true
const canProceed = Boolean.and(isValid, isActive) // false

// OR operation - at least one must be true  
const hasAccess = Boolean.or(isValid, isActive) // true

// NOT operation - logical negation
const isInactive = Boolean.not(isActive) // true

// Pipeable operations for chaining
const complexCondition = pipe(
  isValid,
  Boolean.and(isActive),
  Boolean.or(true)
) // true

Pattern 2: Advanced Boolean Algebra

import { Boolean } from "effect"

// XOR - exactly one must be true
const hasExclusiveAccess = Boolean.xor(isVip, isEmployee) // true if only one is true

// NAND - not both true (inverse of AND)
const notBothRequired = Boolean.nand(hasPermission, hasRole) // false if both true

// NOR - neither is true (inverse of OR) 
const neitherApplies = Boolean.nor(isBlocked, isSuspended) // true if both false

// IMPLIES - logical implication (if A then B)
const followsRule = Boolean.implies(isGuest, hasLimitedAccess) // false only if guest without limits

// EQV - both have same truth value (logical equivalence)
const sameStatus = Boolean.eqv(isActive, isVerified) // true if both same

Pattern 3: Pattern Matching and Conditional Logic

import { Boolean, Effect } from "effect"

// Clean conditional logic with pattern matching
const getStatusMessage = Boolean.match({
  onTrue: () => "System is operational",
  onFalse: () => "System is down for maintenance"
})

const statusMessage = getStatusMessage(systemStatus) // "System is operational" or maintenance message

// Effectful pattern matching for complex scenarios
const handleUserStatus = (isActive: boolean) => Effect.gen(function* () {
  const response = Boolean.match(isActive, {
    onTrue: () => Effect.succeed("Welcome back!"),
    onFalse: () => Effect.fail(new Error("Account is deactivated"))
  })
  
  return yield* response
})

Real-World Examples

Example 1: User Authorization System

A comprehensive authorization system that checks multiple conditions for user access.

import { Boolean, Effect, Array as Arr } from "effect"

interface User {
  id: string
  isActive: boolean
  role: 'admin' | 'moderator' | 'user'
  permissions: string[]
  membershipLevel: 'basic' | 'premium' | 'enterprise'
  lastLoginDays: number
}

interface Resource {
  id: string
  isPublic: boolean
  ownerId: string
  requiredPermissions: string[]
  accessLevel: 'public' | 'private' | 'restricted'
}

// Composable authorization predicates
const isActiveUser = (user: User): boolean => user.isActive
const isRecentlyActive = (user: User): boolean => user.lastLoginDays <= 30
const hasAdminRole = (user: User): boolean => user.role === 'admin'
const hasModerationRole = (user: User): boolean => user.role === 'moderator'
const isPremiumMember = (user: User): boolean => user.membershipLevel !== 'basic'

// Resource access predicates
const isPublicResource = (resource: Resource): boolean => resource.isPublic
const ownsResource = (user: User, resource: Resource): boolean => resource.ownerId === user.id
const hasRequiredPermissions = (user: User, resource: Resource): boolean =>
  Boolean.every(resource.requiredPermissions.map(permission => 
    user.permissions.includes(permission)
  ))

// Complex authorization logic using boolean algebra
const canAccessResource = (user: User, resource: Resource): Effect.Effect<boolean> =>
  Effect.gen(function* () {
    const isUserActive = isActiveUser(user)
    const isRecentUser = isRecentlyActive(user)
    
    // Base access requirement: user must be active
    if (!isUserActive) {
      return false
    }
    
    // Admin can access anything
    if (hasAdminRole(user)) {
      return true
    }
    
    // Public resources are accessible to all active users
    if (isPublicResource(resource)) {
      return true
    }
    
    // Private resources require ownership or special permissions
    const hasOwnership = ownsResource(user, resource)
    const hasPermissions = hasRequiredPermissions(user, resource)
    const isModerator = hasModerationRole(user)
    const isPremium = isPremiumMember(user)
    
    // Build complex authorization logic
    const canAccessPrivate = Boolean.or(
      hasOwnership,
      Boolean.and(hasPermissions, isRecentUser)
    )
    
    const canAccessRestricted = Boolean.and(
      Boolean.or(isModerator, isPremium),
      Boolean.and(hasPermissions, isRecentUser)
    )
    
    return Boolean.match(resource.accessLevel, {
      onTrue: () => canAccessRestricted,  // This is simplified for demo
      onFalse: () => canAccessPrivate
    })
  })

// Usage example
const authorizationService = {
  checkAccess: (user: User, resource: Resource) => Effect.gen(function* () {
    const hasAccess = yield* canAccessResource(user, resource)
    
    return Boolean.match(hasAccess, {
      onTrue: () => Effect.succeed({ granted: true, message: "Access granted" }),
      onFalse: () => Effect.fail(new Error("Access denied"))
    })
  })
}

Example 2: Feature Flag System

A feature flagging system that combines multiple boolean conditions to determine feature availability.

import { Boolean, Effect, Array as Arr } from "effect"

interface FeatureFlag {
  name: string
  isEnabled: boolean
  rolloutPercentage: number
  requiredRoles: string[]
  excludedRoles: string[] 
  minimumVersion: string
  environments: string[]
}

interface FeatureContext {
  userId: string
  userRole: string
  appVersion: string
  environment: string
  isTestUser: boolean
  userHash: number // for percentage rollout
}

// Boolean predicates for feature evaluation
const isFeatureEnabled = (flag: FeatureFlag): boolean => flag.isEnabled

const isInRolloutPercentage = (flag: FeatureFlag, context: FeatureContext): boolean =>
  context.userHash % 100 < flag.rolloutPercentage

const hasRequiredRole = (flag: FeatureFlag, context: FeatureContext): boolean =>
  Boolean.or(
    Arr.isEmptyArray(flag.requiredRoles),
    flag.requiredRoles.includes(context.userRole)
  )

const isNotExcludedRole = (flag: FeatureFlag, context: FeatureContext): boolean =>
  Boolean.not(flag.excludedRoles.includes(context.userRole))

const meetsVersionRequirement = (flag: FeatureFlag, context: FeatureContext): boolean =>
  context.appVersion >= flag.minimumVersion

const isInValidEnvironment = (flag: FeatureFlag, context: FeatureContext): boolean =>
  flag.environments.includes(context.environment)

// Comprehensive feature evaluation using boolean composition
const evaluateFeatureFlag = (flag: FeatureFlag, context: FeatureContext): Effect.Effect<boolean> =>
  Effect.gen(function* () {
    // Test users always get features (for testing purposes)
    if (context.isTestUser) {
      return true
    }
    
    // Build evaluation chain
    const basicChecks = Boolean.and(
      isFeatureEnabled(flag),
      isInValidEnvironment(flag, context)
    )
    
    const userEligibility = Boolean.and(
      hasRequiredRole(flag, context),
      isNotExcludedRole(flag, context)
    )
    
    const technicalRequirements = Boolean.and(
      meetsVersionRequirement(flag, context),
      isInRolloutPercentage(flag, context)
    )
    
    // Combine all conditions
    const finalResult = Boolean.and(
      basicChecks,
      Boolean.and(userEligibility, technicalRequirements)
    )
    
    return finalResult
  })

// Feature flag service with comprehensive logging
const featureFlagService = {
  isEnabled: (flagName: string, context: FeatureContext) => Effect.gen(function* () {
    const flag = yield* getFeatureFlag(flagName)
    const isEnabled = yield* evaluateFeatureFlag(flag, context)
    
    // Log evaluation results for debugging
    const evaluationSteps = {
      flagEnabled: isFeatureEnabled(flag),
      validEnvironment: isInValidEnvironment(flag, context),
      roleEligible: hasRequiredRole(flag, context),
      notExcluded: isNotExcludedRole(flag, context),
      versionMet: meetsVersionRequirement(flag, context),
      inRollout: isInRolloutPercentage(flag, context)
    }
    
    return Boolean.match(isEnabled, {
      onTrue: () => ({ enabled: true, reason: "All conditions met", evaluationSteps }),
      onFalse: () => ({ enabled: false, reason: "Conditions not met", evaluationSteps })
    })
  }),
  
  // Bulk feature evaluation for performance
  evaluateMultiple: (flagNames: string[], context: FeatureContext) => Effect.gen(function* () {
    const results = yield* Effect.all(
      flagNames.map(name => 
        featureFlagService.isEnabled(name, context).pipe(
          Effect.map(result => ({ flagName: name, ...result }))
        )
      )
    )
    
    const allEnabled = Boolean.every(results.map(r => r.enabled))
    const anyEnabled = Boolean.some(results.map(r => r.enabled))
    
    return {
      results,
      summary: {
        allEnabled,
        anyEnabled,
        enabledCount: results.filter(r => r.enabled).length,
        totalCount: results.length
      }
    }
  })
}

// Helper function placeholder
const getFeatureFlag = (name: string): Effect.Effect<FeatureFlag> =>
  Effect.succeed({
    name,
    isEnabled: true,
    rolloutPercentage: 50,
    requiredRoles: [],
    excludedRoles: ['banned'],
    minimumVersion: '1.0.0',
    environments: ['production', 'staging']
  })

Example 3: Business Rule Engine

A flexible business rule engine that uses boolean composition to evaluate complex business conditions.

import { Boolean, Effect, Array as Arr } from "effect"

interface BusinessRule {
  id: string
  name: string
  conditions: RuleCondition[]
  operator: 'AND' | 'OR' | 'XOR'
  isActive: boolean
}

interface RuleCondition {
  field: string
  operator: 'equals' | 'not_equals' | 'greater_than' | 'less_than' | 'contains'
  value: unknown
  weight: number
}

interface RuleContext {
  data: Record<string, unknown>
  metadata: {
    timestamp: number
    source: string
    version: string
  }
}

// Rule evaluation predicates
const evaluateCondition = (condition: RuleCondition, context: RuleContext): boolean => {
  const fieldValue = context.data[condition.field]
  
  switch (condition.operator) {
    case 'equals':
      return fieldValue === condition.value
    case 'not_equals':
      return fieldValue !== condition.value
    case 'greater_than':
      return typeof fieldValue === 'number' && 
             typeof condition.value === 'number' && 
             fieldValue > condition.value
    case 'less_than':
      return typeof fieldValue === 'number' && 
             typeof condition.value === 'number' && 
             fieldValue < condition.value
    case 'contains':
      return typeof fieldValue === 'string' && 
             typeof condition.value === 'string' && 
             fieldValue.includes(condition.value)
    default:
      return false
  }
}

// Business rule engine with boolean composition
const businessRuleEngine = {
  evaluateRule: (rule: BusinessRule, context: RuleContext): Effect.Effect<boolean> =>
    Effect.gen(function* () {
      if (!rule.isActive) {
        return false
      }
      
      // Evaluate all conditions
      const conditionResults = rule.conditions.map(condition =>
        evaluateCondition(condition, context)
      )
      
      // Apply rule operator using boolean algebra
      const ruleResult = Boolean.match(rule.operator, {
        onTrue: () => {
          switch (rule.operator) {
            case 'AND':
              return Boolean.every(conditionResults)
            case 'OR':
              return Boolean.some(conditionResults)
            case 'XOR':
              return conditionResults.reduce(Boolean.xor, false)
            default:
              return false
          }
        },
        onFalse: () => false
      })
      
      return ruleResult
    }),
  
  // Evaluate multiple rules with different combination strategies
  evaluateRuleSet: (rules: BusinessRule[], context: RuleContext, strategy: 'all' | 'any' | 'majority') =>
    Effect.gen(function* () {
      const ruleResults = yield* Effect.all(
        rules.map(rule => 
          businessRuleEngine.evaluateRule(rule, context).pipe(
            Effect.map(result => ({ ruleId: rule.id, result, ruleName: rule.name }))
          )
        )
      )
      
      const results = ruleResults.map(r => r.result)
      const passedCount = results.filter(Boolean).length
      const totalCount = results.length
      
      const finalResult = Boolean.match(strategy, {
        onTrue: () => {
          switch (strategy) {
            case 'all':
              return Boolean.every(results)
            case 'any':
              return Boolean.some(results)
            case 'majority':
              return passedCount > totalCount / 2
            default:
              return false
          }
        },
        onFalse: () => false
      })
      
      return {
        passed: finalResult,
        details: {
          passedCount,
          totalCount,
          passedRules: ruleResults.filter(r => r.result),
          failedRules: ruleResults.filter(r => !r.result)
        }
      }
    }),
  
  // Advanced rule composition with weighted conditions
  evaluateWeightedRule: (rule: BusinessRule, context: RuleContext, threshold: number) =>
    Effect.gen(function* () {
      const weightedResults = rule.conditions.map(condition => ({
        passed: evaluateCondition(condition, context),
        weight: condition.weight
      }))
      
      const totalWeight = weightedResults.reduce((sum, result) => sum + result.weight, 0)
      const passedWeight = weightedResults
        .filter(result => result.passed)
        .reduce((sum, result) => sum + result.weight, 0)
      
      const weightedScore = totalWeight > 0 ? passedWeight / totalWeight : 0
      const thresholdMet = weightedScore >= threshold
      
      return {
        passed: thresholdMet,
        score: weightedScore,
        threshold,
        details: weightedResults
      }
    })
}

// Usage example with complex business logic
const orderValidationRules: BusinessRule[] = [
  {
    id: 'order-minimum',
    name: 'Minimum Order Value',
    conditions: [
      { field: 'orderTotal', operator: 'greater_than', value: 10, weight: 1 }
    ],
    operator: 'AND',
    isActive: true
  },
  {
    id: 'customer-eligibility',
    name: 'Customer Eligibility',
    conditions: [
      { field: 'customerType', operator: 'not_equals', value: 'blocked', weight: 2 },
      { field: 'accountAge', operator: 'greater_than', value: 30, weight: 1 }
    ],
    operator: 'AND',
    isActive: true
  }
]

Advanced Features Deep Dive

Pattern Matching with Boolean.match

Boolean.match provides a functional alternative to if-else statements, enabling cleaner conditional logic.

Basic Boolean.match Usage

import { Boolean, Effect } from "effect"

// Simple pattern matching
const getSystemStatus = (isOnline: boolean): string =>
  Boolean.match(isOnline, {
    onTrue: () => "System is operational",
    onFalse: () => "System is offline"
  })

// Pattern matching with side effects
const handleConnectionStatus = (isConnected: boolean) =>
  Boolean.match(isConnected, {
    onTrue: () => Effect.succeed("Connected successfully"),
    onFalse: () => Effect.fail(new Error("Connection lost"))
  })

Real-World Pattern Matching Example

import { Boolean, Effect, Console } from "effect"

interface PaymentResult {
  success: boolean
  transactionId?: string
  errorMessage?: string
}

// Complex pattern matching for payment processing
const processPaymentResult = (result: PaymentResult) => Effect.gen(function* () {
  const response = Boolean.match(result.success, {
    onTrue: () => Effect.gen(function* () {
      yield* Console.log(`Payment successful: ${result.transactionId}`)
      yield* Effect.succeed({ 
        status: "completed", 
        transactionId: result.transactionId 
      })
    }),
    onFalse: () => Effect.gen(function* () {
      yield* Console.error(`Payment failed: ${result.errorMessage}`)
      yield* Effect.fail(new Error(`Payment processing failed: ${result.errorMessage}`))
    })
  })
  
  return yield* response
})

// Pipeable pattern matching for chaining
const validateAndProcessPayment = (amount: number, isValid: boolean) =>
  Effect.succeed(isValid).pipe(
    Effect.flatMap(Boolean.match({
      onTrue: () => processPayment(amount),
      onFalse: () => Effect.fail(new Error("Invalid payment data"))
    }))
  )

const processPayment = (amount: number): Effect.Effect<PaymentResult> =>
  Effect.succeed({
    success: amount > 0,
    transactionId: amount > 0 ? `tx_${Date.now()}` : undefined,
    errorMessage: amount <= 0 ? "Invalid amount" : undefined
  })

Advanced Boolean Algebra: XOR, NAND, NOR, EQV, IMPLIES

These operations enable sophisticated logical expressions for complex business rules.

XOR (Exclusive OR): Exactly One Condition

import { Boolean } from "effect"

// User can have either VIP access OR employee access, but not both
const hasExclusiveAccess = (isVip: boolean, isEmployee: boolean): boolean =>
  Boolean.xor(isVip, isEmployee)

// Feature flags: enable feature in staging OR production, but not both
const shouldEnableFeature = (inStaging: boolean, inProduction: boolean): boolean =>
  Boolean.xor(inStaging, inProduction)

// Exclusive payment methods
const hasSinglePaymentMethod = (hasCreditCard: boolean, hasPayPal: boolean): boolean =>
  Boolean.xor(hasCreditCard, hasPayPal)

NAND (Not AND): At Least One Must Be False

import { Boolean } from "effect"

// Security rule: user cannot be both external AND have admin privileges
const securityCompliant = (isExternal: boolean, hasAdminAccess: boolean): boolean =>
  Boolean.nand(isExternal, hasAdminAccess)

// Resource contention: two processes cannot both be writing simultaneously
const noWriteConflict = (process1Writing: boolean, process2Writing: boolean): boolean =>
  Boolean.nand(process1Writing, process2Writing)

IMPLIES: Logical Implication

import { Boolean } from "effect"

// Business rule: if customer is premium, they must have support access
const premiumRuleFollowed = (isPremium: boolean, hasSupportAccess: boolean): boolean =>
  Boolean.implies(isPremium, hasSupportAccess)

// Security rule: if accessing sensitive data, must be authenticated
const securityRuleFollowed = (accessingSensitiveData: boolean, isAuthenticated: boolean): boolean =>
  Boolean.implies(accessingSensitiveData, isAuthenticated)

// Conditional validation: if order is international, must have customs info
const internationalOrderValid = (isInternational: boolean, hasCustomsInfo: boolean): boolean =>
  Boolean.implies(isInternational, hasCustomsInfo)

Collection Operations: every and some

Efficient operations for validating arrays of boolean values.

Using Boolean.every for All-or-Nothing Validation

import { Boolean, Array as Arr } from "effect"

interface ValidationResult {
  field: string
  isValid: boolean
  message?: string
}

// Validate all form fields pass
const validateForm = (validationResults: ValidationResult[]): boolean =>
  Boolean.every(validationResults.map(result => result.isValid))

// Check if all services are healthy
const allServicesHealthy = (healthChecks: boolean[]): boolean =>
  Boolean.every(healthChecks)

// Permission checking: user must have ALL required permissions
const hasAllRequiredPermissions = (userPermissions: string[], requiredPermissions: string[]): boolean =>
  Boolean.every(requiredPermissions.map(permission => 
    userPermissions.includes(permission)
  ))

Using Boolean.some for Any-Match Validation

import { Boolean } from "effect"

// Check if user has ANY of the acceptable roles
const hasAcceptableRole = (userRoles: string[], acceptableRoles: string[]): boolean =>
  Boolean.some(acceptableRoles.map(role => userRoles.includes(role)))

// Feature availability: feature is available if ANY environment supports it
const isFeatureAvailable = (environmentSupport: boolean[]): boolean =>
  Boolean.some(environmentSupport)

// Payment validation: order is payable if ANY payment method is valid
const canProcessPayment = (paymentMethods: PaymentMethod[]): boolean =>
  Boolean.some(paymentMethods.map(method => method.isValid))

interface PaymentMethod {
  type: string
  isValid: boolean
}

Practical Patterns & Best Practices

Pattern 1: Composable Validation Predicates

Create reusable validation functions that can be combined using boolean algebra.

import { Boolean, pipe } from "effect"

interface User {
  age: number
  email: string
  isVerified: boolean
  accountType: 'free' | 'premium' | 'enterprise'
  lastLoginDays: number
}

// Atomic predicates
const isAdult = (user: User): boolean => user.age >= 18
const hasValidEmail = (user: User): boolean => user.email.includes('@') && user.email.length > 0
const isVerified = (user: User): boolean => user.isVerified
const isPremiumOrEnterprise = (user: User): boolean => user.accountType !== 'free'
const isRecentlyActive = (user: User): boolean => user.lastLoginDays <= 30

// Composable validation functions
const validateBasicUser = (user: User): boolean =>
  Boolean.and(
    isAdult(user),
    Boolean.and(hasValidEmail(user), isVerified(user))
  )

const validatePremiumUser = (user: User): boolean =>
  Boolean.and(
    validateBasicUser(user),
    isPremiumOrEnterprise(user)
  )

const validateActiveUser = (user: User): boolean =>
  Boolean.and(
    validateBasicUser(user),
    isRecentlyActive(user)
  )

// Higher-order validation composer
const createUserValidator = (predicates: Array<(user: User) => boolean>) =>
  (user: User): boolean => Boolean.every(predicates.map(predicate => predicate(user)))

// Usage
const premiumActiveUserValidator = createUserValidator([
  isAdult,
  hasValidEmail,
  isVerified,
  isPremiumOrEnterprise,
  isRecentlyActive
])

Pattern 2: Boolean State Machines

Use boolean combinations to model state transitions and business workflows.

import { Boolean, Effect } from "effect"

interface OrderState {
  isCreated: boolean
  isPaid: boolean
  isShipped: boolean
  isDelivered: boolean
  isCancelled: boolean
}

interface OrderTransitions {
  canPay: (state: OrderState) => boolean
  canShip: (state: OrderState) => boolean
  canDeliver: (state: OrderState) => boolean
  canCancel: (state: OrderState) => boolean
}

// Boolean-based state machine for order processing
const orderStateMachine: OrderTransitions = {
  // Can pay if created but not paid, and not cancelled
  canPay: (state) => Boolean.and(
    state.isCreated,
    Boolean.and(Boolean.not(state.isPaid), Boolean.not(state.isCancelled))
  ),
  
  // Can ship if paid but not shipped, and not cancelled
  canShip: (state) => Boolean.and(
    state.isPaid,
    Boolean.and(Boolean.not(state.isShipped), Boolean.not(state.isCancelled))
  ),
  
  // Can deliver if shipped but not delivered, and not cancelled
  canDeliver: (state) => Boolean.and(
    state.isShipped,
    Boolean.and(Boolean.not(state.isDelivered), Boolean.not(state.isCancelled))
  ),
  
  // Can cancel if not delivered and not already cancelled
  canCancel: (state) => Boolean.and(
    Boolean.not(state.isDelivered),
    Boolean.not(state.isCancelled)
  )
}

// State transition service
const orderService = {
  validateTransition: (currentState: OrderState, action: keyof OrderTransitions) =>
    Effect.gen(function* () {
      const canTransition = orderStateMachine[action](currentState)
      
      return Boolean.match(canTransition, {
        onTrue: () => Effect.succeed(`Can perform ${action}`),
        onFalse: () => Effect.fail(new Error(`Cannot perform ${action} in current state`))
      })
    }),
  
  getAvailableActions: (state: OrderState) => {
    const actions: Array<{ action: keyof OrderTransitions; canPerform: boolean }> = [
      { action: 'canPay', canPerform: orderStateMachine.canPay(state) },
      { action: 'canShip', canPerform: orderStateMachine.canShip(state) },
      { action: 'canDeliver', canPerform: orderStateMachine.canDeliver(state) },
      { action: 'canCancel', canPerform: orderStateMachine.canCancel(state) }
    ]
    
    return actions.filter(action => action.canPerform)
  }
}

Pattern 3: Boolean Circuit Breaker

Implement circuit breaker patterns using boolean logic for system resilience.

import { Boolean, Effect, Ref } from "effect"

interface CircuitBreakerState {
  failureCount: number
  lastFailureTime: number
  isOpen: boolean
  successCount: number
}

interface CircuitBreakerConfig {
  maxFailures: number
  timeoutMs: number
  successThreshold: number
}

// Boolean-based circuit breaker implementation
const createCircuitBreaker = (config: CircuitBreakerConfig) => {
  const initialState: CircuitBreakerState = {
    failureCount: 0,
    lastFailureTime: 0,
    isOpen: false,
    successCount: 0
  }
  
  return Effect.gen(function* () {
    const stateRef = yield* Ref.make(initialState)
    
    const shouldOpen = (state: CircuitBreakerState): boolean =>
      state.failureCount >= config.maxFailures
    
    const shouldClose = (state: CircuitBreakerState): boolean =>
      Boolean.and(
        state.isOpen,
        state.successCount >= config.successThreshold
      )
    
    const shouldAttempt = (state: CircuitBreakerState): boolean =>
      Boolean.or(
        Boolean.not(state.isOpen),
        Boolean.and(
          state.isOpen,
          Date.now() - state.lastFailureTime > config.timeoutMs
        )
      )
    
    const execute = <A, E>(effect: Effect.Effect<A, E>) =>
              Effect.gen(function* () {
        const state = yield* Ref.get(stateRef)
        
        const canAttempt = shouldAttempt(state)
        
        if (!canAttempt) {
          return yield* Effect.fail(new Error("Circuit breaker is open"))
        }
        
        const result = yield* Effect.either(effect)
        
        if (result._tag === "Left") {
          // Record failure
          yield* Ref.update(stateRef, currentState => ({
            ...currentState,
            failureCount: currentState.failureCount + 1,
            lastFailureTime: Date.now(),
            isOpen: shouldOpen({ ...currentState, failureCount: currentState.failureCount + 1 }),
            successCount: 0
          }))
          
          return yield* Effect.fail(result.left)
        } else {
          // Record success
          yield* Ref.update(stateRef, currentState => {
            const newState = {
              ...currentState,
              successCount: currentState.successCount + 1,
              failureCount: 0
            }
            
            return {
              ...newState,
              isOpen: Boolean.and(currentState.isOpen, Boolean.not(shouldClose(newState)))
            }
          })
          
          return result.right
        }
      })
    
    const getState = () => Ref.get(stateRef)
    
    return { execute, getState } as const
  })
}

Integration Examples

Integration with Effect and Option

Boolean operations integrate seamlessly with Effect's control flow and Option's null-safe operations.

import { Boolean, Effect, Option, Array as Arr } from "effect"

interface User {
  id: string
  email: Option.Option<string>
  isActive: boolean
  permissions: string[]
}

interface EmailService {
  send: (email: string, message: string) => Effect.Effect<void>
}

// Combining Boolean with Option for safe operations
const notifyActiveUsersWithEmail = (users: User[], message: string, emailService: EmailService) =>
  Effect.gen(function* () {
    const eligibleUsers = users.filter(user => 
      Boolean.and(
        user.isActive,
        Option.isSome(user.email)
      )
    )
    
    const notifications = eligibleUsers.map(user =>
      Option.match(user.email, {
        onNone: () => Effect.unit,
        onSome: (email) => emailService.send(email, message)
      })
    )
    
    yield* Effect.all(notifications, { concurrency: 5 })
    
    return {
      totalUsers: users.length,
      notifiedUsers: eligibleUsers.length,
      success: true
    }
  })

// Boolean validation with Effect error handling
const validateUserAccess = (user: User, requiredPermissions: string[]) =>
  Effect.gen(function* () {
    const isActiveUser = user.isActive
    const hasAllPermissions = Boolean.every(
      requiredPermissions.map(permission => user.permissions.includes(permission))
    )
    
    const hasAccess = Boolean.and(isActiveUser, hasAllPermissions)
    
    return yield* Boolean.match(hasAccess, {
      onTrue: () => Effect.succeed({ userId: user.id, access: "granted" }),
      onFalse: () => Effect.fail(new Error(`Access denied for user ${user.id}`))
    })
  })

Integration with Schema Validation

Use Boolean operations with Effect Schema for complex validation scenarios.

import { Boolean, Schema, Effect } from "effect"

// Boolean schema for configuration
const FeatureConfigSchema = Schema.Struct({
  isEnabled: Schema.Boolean,
  requiresAuth: Schema.Boolean,
  isExperimental: Schema.Boolean,
  environments: Schema.Array(Schema.String)
})

type FeatureConfig = Schema.Schema.Type<typeof FeatureConfigSchema>

interface ValidationContext {
  currentEnvironment: string
  userIsAuthenticated: boolean
  allowExperimental: boolean
}

// Schema validation with boolean logic
const validateFeatureAccess = (
  configData: unknown,
  context: ValidationContext
): Effect.Effect<boolean> =>
  Effect.gen(function* () {
    // Parse and validate schema
    const config = yield* Schema.decodeUnknown(FeatureConfigSchema)(configData)
    
    // Apply boolean logic for access control
    const basicAccess = Boolean.and(
      config.isEnabled,
      config.environments.includes(context.currentEnvironment)
    )
    
    const authRequirement = Boolean.implies(
      config.requiresAuth,
      context.userIsAuthenticated
    )
    
    const experimentalCheck = Boolean.implies(
      config.isExperimental,
      context.allowExperimental
    )
    
    const finalAccess = Boolean.and(
      basicAccess,
      Boolean.and(authRequirement, experimentalCheck)
    )
    
    return finalAccess
  })

// Complex validation combining multiple schemas
const BusinessRuleSchema = Schema.Struct({
  conditions: Schema.Array(Schema.Struct({
    field: Schema.String,
    operator: Schema.Literal("equals", "not_equals", "contains"),
    value: Schema.Unknown,
    required: Schema.Boolean
  })),
  requireAll: Schema.Boolean,
  isActive: Schema.Boolean
})

const validateBusinessRule = (ruleData: unknown, contextData: Record<string, unknown>) =>
  Effect.gen(function* () {
    const rule = yield* Schema.decodeUnknown(BusinessRuleSchema)(ruleData)
    
    if (!rule.isActive) {
      return false
    }
    
    const conditionResults = rule.conditions.map(condition => {
      const fieldValue = contextData[condition.field]
      const conditionMet = Boolean.match(condition.operator, {
        onTrue: () => {
          switch (condition.operator) {
            case 'equals':
              return fieldValue === condition.value
            case 'not_equals':
              return fieldValue !== condition.value
            case 'contains':
              return typeof fieldValue === 'string' && 
                     typeof condition.value === 'string' && 
                     fieldValue.includes(condition.value)
            default:
              return false
          }
        },
        onFalse: () => false
      })
      
      // If condition is required, it must pass; if optional, failure doesn't block
      return Boolean.or(conditionMet, Boolean.not(condition.required))
    })
    
    return Boolean.match(rule.requireAll, {
      onTrue: () => Boolean.every(conditionResults),
      onFalse: () => Boolean.some(conditionResults)
    })
  })

Testing Strategies

Comprehensive testing approaches for Boolean-based logic.

import { Boolean, Effect, TestContext, TestServices } from "effect"
import { describe, it, expect } from "@effect/vitest"

// Property-based testing for boolean operations
describe("Boolean Operations", () => {
  it("should satisfy boolean algebra laws", () => {
    const testCases = [
      { a: true, b: true },
      { a: true, b: false },
      { a: false, b: true },
      { a: false, b: false }
    ]
    
    testCases.forEach(({ a, b }) => {
      // Commutative law: a AND b = b AND a
      expect(Boolean.and(a, b)).toBe(Boolean.and(b, a))
      expect(Boolean.or(a, b)).toBe(Boolean.or(b, a))
      
      // De Morgan's laws
      expect(Boolean.not(Boolean.and(a, b))).toBe(Boolean.or(Boolean.not(a), Boolean.not(b)))
      expect(Boolean.not(Boolean.or(a, b))).toBe(Boolean.and(Boolean.not(a), Boolean.not(b)))
      
      // Double negation
      expect(Boolean.not(Boolean.not(a))).toBe(a)
    })
  })
  
  it("should handle complex boolean expressions", () => {
    const complexExpression = (p: boolean, q: boolean, r: boolean): boolean =>
      Boolean.or(
        Boolean.and(p, q),
        Boolean.and(Boolean.not(p), r)
      )
    
    // Test truth table
    expect(complexExpression(true, true, false)).toBe(true)   // p AND q
    expect(complexExpression(true, false, true)).toBe(false)  // p AND NOT q
    expect(complexExpression(false, true, true)).toBe(true)   // NOT p AND r
    expect(complexExpression(false, false, false)).toBe(false) // NOT p AND NOT r
  })
})

// Integration testing with Effect
describe("Boolean with Effect Integration", () => {
  it("should handle effectful boolean operations", () =>
    Effect.gen(function* () {
      const getUserPermissions = (userId: string): Effect.Effect<string[]> =>
        Effect.succeed(['read', 'write'])
      
      const checkPermission = (userId: string, requiredPermission: string) =>
        Effect.gen(function* () {
          const permissions = yield* getUserPermissions(userId)
          return permissions.includes(requiredPermission)
        })
      
      const hasReadPermission = yield* checkPermission("user1", "read")
      const hasWritePermission = yield* checkPermission("user1", "write")
      const hasDeletePermission = yield* checkPermission("user1", "delete")
      
      const canRead = hasReadPermission
      const canModify = Boolean.and(hasReadPermission, hasWritePermission)
      const cannotDelete = Boolean.not(hasDeletePermission)
      
      expect(canRead).toBe(true)
      expect(canModify).toBe(true)
      expect(cannotDelete).toBe(true)
    }).pipe(Effect.provide(TestServices.TestContext))
  )
})

// Mock testing strategies
const createBooleanTestHelper = () => ({
  // Generate test data for boolean operations
  generateBooleanCombinations: (count: number) => {
    const combinations: Array<{ values: boolean[], expected: { and: boolean, or: boolean } }> = []
    
    for (let i = 0; i < Math.pow(2, count); i++) {
      const values = Array.from({ length: count }, (_, index) => Boolean(i & (1 << index)))
      const expected = {
        and: Boolean.every(values),
        or: Boolean.some(values)
      }
      combinations.push({ values, expected })
    }
    
    return combinations
  },
  
  // Test boolean predicates
  testPredicate: <T>(predicate: (value: T) => boolean, testCases: Array<{ input: T, expected: boolean }>) => {
    testCases.forEach(({ input, expected }) => {
      expect(predicate(input)).toBe(expected)
    })
  }
})

Conclusion

Boolean provides functional, composable tools for building clear, maintainable boolean logic in TypeScript applications. It transforms complex conditional logic into readable, testable, and reusable components.

Key benefits:

  • Composability: Boolean operations can be easily combined and reused across different contexts
  • Readability: Functional approach makes complex logic easier to understand and maintain
  • Type Safety: Full TypeScript integration with proper type inference and checking
  • Integration: Seamless interoperability with other Effect modules like Option, Effect, and Schema

The Boolean module excels in scenarios requiring complex conditional logic, such as authorization systems, feature flags, business rule engines, and validation frameworks. By leveraging functional composition and boolean algebra, you can build robust, maintainable logic that scales with your application's complexity.