Mirror of forum.nim-lang.org

10465 :: How to pass an optional callback to a proc

• DMisener (orginal) [2023-09-07T05:50:08+02:00] view original

  Given the following examplar:

  import std/options
  
  type
    Callback = Option[proc(name: string, length: int)]
    
    TestOptions = object
      name: string
      length: int
      callback: Callback
  
  proc show(name: string, length: int) =
    echo "Callback executed: ", name, " is ", length, " inches long"
  
  let  option1 = TestOptions(name: "foot", length: 12)
  let  option2 = TestOptions(name: "inch", length:  1)
  #let option3 = TestOptions(name: "yard", length:  36, callback: some(show)) # FIXME: uncomment
  
  proc test(options: TestOptions) =
    echo "Options = ", options
    
    if options.callback.isSome:
      options.callback.get()(options.name, options.length)
    else:
      echo "No callback supplied"
  
  test  option1
  test  option2
  #test option3 # FIXME: uncomment
  Run

  Running the code gives:

  
  nim r tests/test_options.nim
  Options = (name: "foot", length: 12, callback: ...)
  No callback supplied
  Options = (name: "inch", length: 1, callback: ...)
  No callback supplied
  Run

  If I uncomment the two FIXME lines to test actually supplying a callback, I get the following compile error:

  
  nim r tests/test_options.nim
  /Users/DM/work/trunk/nim/tests/test_options.nim(16, 62)
  Error: type mismatch: got 'Option[proc (name: string, length: int){.gcsafe.}]' for 'some(show)' but
   expected 'Callback = Option[proc (name: string, length: int){.closure.}]'
  Run

  Anyone know the magic incantation to allow the code to compile and hopefully run? I tried sprinkling {.closure.} and {.gcsafe.} pragmas around with no success.

---

• Isofruit (orginal) [2023-09-07T06:24:25+02:00] view original

  Your problem is the type system and that there is different procedural types.

  A normal proc in nim always is of type nimcall. A normal unnamed proc (like you have when you use it as a type to store it in TestOptions) is always of type closure so you can have an environment.

  You have 2 options, either:

  1. you explicitly tell your Callback type that it stores a proc of type nimcall (which you should do if you don't access global variables in that proc) or

  2. you define your show proc as an unnamed proc that you assign to a show variable`closure` (which you should do if you do plan on accessing global variables).

  For 1 simply change your callback definition: ` Callback = Option[proc(name: string, length: int) {.nimcall.}]`

  For 2 simply change your proc definition:

  const show =proc(name: string, length: int) {.closure.} =
    echo "Callback executed: ", name, " is ", length, " inches long"
  Run

---

• PMunch (orginal) [2023-09-07T10:22:32+02:00] view original

  Note also that procedures are a pointer type under the hood, so you don't really need Option:

  import std/options
  
  type
    Callback = proc(name: string, length: int) {.nimcall.}
    
    TestOptions = object
      name: string
      length: int
      callback: Callback
  
  proc show(name: string, length: int) =
    echo "Callback executed: ", name, " is ", length, " inches long"
  
  let
    option1 = TestOptions(name: "foot", length: 12)
    option2 = TestOptions(name: "inch", length:  1)
    option3 = TestOptions(name: "yard", length:  36, callback: show)
  
  proc test(options: TestOptions) =
    echo "Options = ", options
    
    if not options.callback.isNil:
      options.callback(options.name, options.length)
    else:
      echo "No callback supplied"
  
  test option1
  test option2
  test option3
  Run

  The options module knows this, and basically just turns into a null-check in this scenario, so it's just a matter of ergonomics and preference which one you use.

---

• DMisener (orginal) [2023-09-07T14:41:56+02:00] view original

  Thank you very much for the excellent explanation. It all makes so much sense now.

  I combined PMunch's suggustion plus a small variant of your second option. to yield:

  type
    Callback = proc(name: string, length: int)
    
    TestOptions = object
      name: string
      length: int
      callback: Callback
  
  const show = proc(name: string, length: int) =
    echo "Callback executed: ", name, " is ", length, " inches long"
  
  let option1 = TestOptions(name: "foot", length: 12)
  let option2 = TestOptions(name: "inch", length:  1)
  let option3 = TestOptions(name: "yard", length:  36, callback: show)
  
  proc test(options: TestOptions) =
    if options.callback.isNil:
      echo "No callback supplied"
    else:
      options.callback(options.name, options.length)
  
  test option1
  test option2
  test option3
  Run

  which gives the desired result:

  
  nim r tests/test_options.nim
  No callback supplied
  No callback supplied
  Callback executed: yard is 36 inches long
  Run

  Lessons learned:

  • A normal unnamed proc type defaults to a type closure so you can have an environment.
  • Procedures are a simply pointer type and so isNil is available for checking if defined.

---

• DMisener (orginal) [2023-09-07T14:48:07+02:00] view original

  Excellent! ... Thanks ... I prefer the isNil to the option alternative... less syntactic clutter. I will be using that little piece of knowledge going forward.

  See my revised code above and let feel free to comment on any other ergonomics and preference related suggestions. I really do learn from such feedback.

---

• Isofruit (orginal) [2023-09-07T17:07:43+02:00] view original

  While syntactic clutter, using options also means you're less likely to accidentally blow up your application. Having to call "get" is a little stronger a reminder that a given proc may not exist and you may run into nil-access-defects which will crash and burn down your entire application. Thus I always tend to use Option to express something does not exist, never nil. I've had enough of nil checks for ref-types from my time in java.

  That kind of safety I'd value more than the syntactic niceness of isNil.

---