Scala - Prefix Unary Operators

Question

Gần đây tôi đã cho Scala một cơ hội thứ hai, và bắt đầu với dự án tôi luôn thực hiện (bằng ngôn ngữ chức năng hoặc giả): một lý do tự động cho logic mệnh đề (và sau này là logic vị ngữ).

Bây giờ, tôi đã cố gắng để có được những ký hiệu của logic mệnh đề bằng ngôn ngữ riêng của mình như khá càng tốt, và tôi đã nhận được điều này đến nay - với một chuyển đổi ngầm (String -> Atom):

("A" and "B") implies "C" 

Các hàm "và" và "ngụ ý" (và "hoặc" và "tương đương") là các phương thức đơn giản gọi hàm tạo lớp có liên quan. Tuy nhiên, khi thực hiện "không", tôi gặp khó khăn với một trong hai ký hiệu sau:

("A" and "B").not 
Not("A" and "B") 

Có cách nào để lừa Scala vào chấp nhận mong muốn:

not("A" and "B") 

Ưu tiên sử dụng mà không cần đổi tên lớp "Không" để "không", bởi vì tôi có thể muốn gọi nó là "¬" hoặc cái gì khác, trong tương lai.

Answer 1

Kể từ tháng 2 năm 2014, tôi nghĩ cách sạch nhất để xác định tiền tố not hoạt động trên biểu thức, trong khi tránh tất cả các loại bổ sung/gói, sẽ khai báo chức năng trực tiếp trong phạm vi gói. các hàm, lớp, kiểu khác của bạn vv: Điều này được thực hiện bằng cách định nghĩa một đối tượng gói (Scala không cho phép bạn chỉ đặt các hàm ở cấp cơ sở của tệp .scala (tôi rất muốn tìm hiểu tại sao) Bước chân của Java?)).

package org.my.logiclib 

implicit class Atom(s: String) { ... } 
class MyType1 
class MyType2 

object `package` { 
    def not(expr: Expr) = ... 
} 

theo cách này, làm import org.my.logiclib._ sẽ nhập mọi thứ, bao gồm not().

Trên đây là giống như

package org.my 

package logiclib { 
    implicit class Atom ... 
    ... 

    def not(expr: Expr) = ... 
} 

Answer 2

Bạn có thể xác định not như một phương thức trên một đối tượng singleton, như thế này:

object Logic { 
    def not(x:Expr) = Not(x) 
} 
import Logic._ 
not("A" and "B") 

(Trong trường hợp Expr được coi là lớp cha chung của And, Or, Not và Atom)

Sửa : Dưới đây là ví dụ về cách sử dụng điều này chỉ với một lần nhập:

object Logic { 
    abstract class Expr { 
    def and(e: Expr) = Conjunction(this, e) 
    def or(e: Expr) = Disjunction(this, e) 
    def implies(e: Expr) = Implication(this, e) 
    } 
    case class Conjunction(e1: Expr, e2: Expr) extends Expr 
    case class Disjunction(e1: Expr, e2: Expr) extends Expr 
    case class Implication(e1: Expr, e2: Expr) extends Expr 
    case class Negation(e: Expr) extends Expr 
    case class Atom(name: String) extends Expr 

    def not(e: Expr) = Negation(e) 
    implicit def string2atom(str: String) = Atom(str) 
} 

// use site 
import Logic._ 
not("A" and "B") implies (not("A") or not("B")) 

Answer 3

Tôi nhận thấy trên this answer cho một câu hỏi khác có vẻ như người ta có thể đặt tiền tố tên nhà điều hành với unary_ để đạt được những gì bạn đang cố gắng làm. (Xem unary_!.)

Chỉnh sửa: this article xác nhận cú pháp.

Answer 4

Tại sao Not thay vì not? Không có gì ngăn bạn làm việc này:

object not { 
    def apply(expr: T) = ... 
} 

Và sau đó sử dụng not("A" and "B").